// 添加jQuery冲突保护
if (typeof jQuery === 'undefined' && typeof $j === 'undefined') {
    // 尝试从父窗口获取jQuery，优先使用$j
    if (typeof window !== 'undefined' && window.parent && window.parent.$j) {
        var $ = window.parent.$j;
    } else if (typeof window !== 'undefined' && window.parent && window.parent.jQuery) {
        var $ = window.parent.jQuery;
    } else if (typeof window !== 'undefined' && window.$j) {
        var $ = window.$j;
    } else if (typeof window !== 'undefined' && window.jQuery) {
        var $ = window.jQuery;
    } else {
        console.error('main.js requires jQuery');
        // 不再抛出错误，而是使用一个空的jQuery对象来避免崩溃
        var $ = function() {
            console.error('jQuery is not available');
            return $;
        };
        $.ajax = function() {
            console.error('jQuery.ajax is not available');
        };
    }
} else {
    // 使用主框架中定义的jQuery别名
    var $ = typeof $j !== 'undefined' ? $j : jQuery;
}

// 确保Chart.js已加载
function checkChartJS() {
    if (typeof Chart === 'undefined') {
        console.error('Chart.js未正确加载');
        return false;
    }
    return true;
}

// 等待资源加载器加载完成
function waitForResourceLoader() {
    return new Promise(resolve => {
        const check = () => {
            if (typeof window.resourceLoader !== 'undefined') {
                resolve(window.resourceLoader);
            } else {
                setTimeout(check, 100);
            }
        };
        check();
    });
}

$(document).ready(function() {  
    // 检查jQuery是否真正可用
    if (typeof $ === 'undefined' || typeof $.ajax === 'undefined') {
        console.error('jQuery is not properly initialized in main.js');
        return;
    }
    
    // 获取已用web空间大小
    $.ajax({
       url: "/main/get_path_size",
       type: "POST",
       success: function (response) {
           // 检查元素是否存在
           if (document.getElementById("web_used_space") && 
               document.getElementById("web_size") && 
               document.getElementById("bytes_used_space") && 
               document.getElementById("progressbar")) {
               
               if (response.size < 1024) {
                   document.getElementById("web_used_space").innerHTML = (response.size).toFixed(1)+'&nbsp;B';
                   web_size=document.getElementById("web_size").innerHTML;
                   percentage = (response.size / (web_size * 1048576)) * 100; // 修正的计算方式
               } else if(response.size < 1024*1024) {
                   document.getElementById("web_used_space").innerHTML = (response.size/1024).toFixed(2)+'&nbsp;K';
                   web_size=document.getElementById("web_size").innerHTML;
                   percentage = ((response.size/1024) / (web_size * 1024)) * 100; // 修正的计算方式
               } else if(response.size < 1024*1024*1024) {
                   document.getElementById("web_used_space").innerHTML = (response.size/1024/1024).toFixed(2)+'&nbsp;M';
                   web_size=document.getElementById("web_size").innerHTML;
                   percentage = ((response.size/1024/1024) / web_size) * 100; // 修正的计算方式
               } else {
                   document.getElementById("web_used_space").innerHTML = (response.size/1024/1024/1024).toFixed(2)+'&nbsp;G';
                   web_size=document.getElementById("web_size").innerHTML;
                   percentage = ((response.size/1024/1024) / (web_size)) * 100; // 修正的计算方式
               }
               
               // 确保百分比在0-100之间
               percentage = Math.max(0, Math.min(100, percentage));
               
               document.getElementById("bytes_used_space").innerHTML = '已用&nbsp;'+percentage.toFixed(2)+'&nbsp;%';
               document.getElementById("progressbar").style.width = percentage.toFixed(2)+'%';
           }
       },
       error: function (xhr, status, error) {
           console.log(error);
       }
   });
   
   // 获取SQL空间使用情况
   $.ajax({
       url: "/main/GetInfo",
       type: "POST",
       success: function (response) {
           // 检查元素是否存在
           if (document.getElementById("sql_used_space") && 
               document.getElementById("sql_size") && 
               document.getElementById("sqlbytes_used_space") && 
               document.getElementById("sqlprogressbar")) {
               
               if (response.size < 1024) {
                   document.getElementById("sql_used_space").innerHTML = (response.size).toFixed(1)+'&nbsp;B';
                   sql_size=document.getElementById("sql_size").innerHTML;
                   percentage = (response.size / (sql_size * 1048576)) * 100; // 修正的计算方式
               } else if(response.size < 1024*1024) {
                   document.getElementById("sql_used_space").innerHTML = (response.size/1024).toFixed(2)+'&nbsp;K';
                   sql_size=document.getElementById("sql_size").innerHTML;
                   percentage = ((response.size/1024) / (sql_size * 1024)) * 100; // 修正的计算方式
               } else if(response.size < 1024*1024*1024) {
                   document.getElementById("sql_used_space").innerHTML = (response.size/1024/1024).toFixed(2)+'&nbsp;M';
                   sql_size=document.getElementById("sql_size").innerHTML;
                   percentage = ((response.size/1024/1024) / sql_size) * 100; // 修正的计算方式
               } else {
                   document.getElementById("sql_used_space").innerHTML = (response.size/1024/1024/1024).toFixed(2)+'&nbsp;G';
                   sql_size=document.getElementById("sql_size").innerHTML;
                   percentage = ((response.size/1024/1024) / (sql_size)) * 100; // 修正的计算方式
               }
               
               // 确保百分比在0-100之间
               percentage = Math.max(0, Math.min(100, percentage));
               
               document.getElementById("sqlbytes_used_space").innerHTML = '已用&nbsp;'+percentage.toFixed(2)+'&nbsp;%';
               document.getElementById("sqlprogressbar").style.width = percentage.toFixed(2)+'%';
           }
       },
       error: function (xhr, status, error) {
           console.log(error);
       }
   });
// 获取流量使用情况
    $.ajax({
       url: '/traffic/statistics',
       type: 'GET',
       success: function (response) {
           console.log(response);
           
           // 检查元素是否存在
           if (document.getElementById("traffic") && 
               document.getElementById("traffic_size") && 
               document.getElementById("traffic_used_space") && 
               document.getElementById("trafficprogressbar")) {
               
               if (response < 1024) {
                   document.getElementById("traffic").innerHTML = (response).toFixed(1)+'&nbsp;B';
                   traffic_size=document.getElementById("traffic_size").innerHTML;
                   percentage = (response / (traffic_size * 1048576)) * 100; // 修正的计算方式
               } else if(response < 1024*1024) {
                   document.getElementById("traffic").innerHTML = (response/1024).toFixed(2)+'&nbsp;K';
                   traffic_size=document.getElementById("traffic_size").innerHTML;
                   percentage = ((response/1024) / (traffic_size * 1024)) * 100; // 修正的计算方式
               } else if(response < 1024*1024*1024) {
                   document.getElementById("traffic").innerHTML = (response/1024/1024).toFixed(2)+'&nbsp;M';
                   traffic_size=document.getElementById("traffic_size").innerHTML;
                   percentage = ((response/1024/1024) / traffic_size) * 100; // 修正的计算方式
               } else {
                   document.getElementById("traffic").innerHTML = (response/1024/1024/1024).toFixed(2)+'&nbsp;G';
                   traffic_size=document.getElementById("traffic_size").innerHTML;
                   percentage = ((response/1024/1024) / (traffic_size)) * 100; // 修正的计算方式
               }
               
               // 确保百分比在0-100之间
               percentage = Math.max(0, Math.min(100, percentage));
               
               document.getElementById("traffic_used_space").innerHTML = '已用&nbsp;'+percentage.toFixed(2)+'&nbsp;%';
               document.getElementById("trafficprogressbar").style.width = percentage.toFixed(2)+'%';
           }
       },
       error: function (xhr, status, error) {
           console.log(error);
       }
   });
 
   // 获取当前php版本
   $.ajax({
    url: '/main/GetSitePHPVersion',
    type: 'POST',
    success: function (data) {
        $.ajax({
            url: '/main/GetPHPVersion',
            type: 'POST',
            success: function (datalist) {
                // 检查元素是否存在
                if (document.getElementById("php")) {
                    // 创建下拉框
                    var select = document.getElementById("php");
                    // 循环添加选项
                    for (var i = 0; i < datalist.length; i++) {  
                        var option = document.createElement('option');  
                        option.value = datalist[i].version;  // 设置下拉菜单的名称  
                        option.innerHTML = datalist[i].name;  // 设置下拉菜单的值 
                        select.add(option);  // 将选项添加到下拉菜单中  
                    } 
                    //设置默认值 
                    select.value = data.phpversion;
                }
            },
            error: function (xhr, status, error) {
                console.log('获取PHP版本列表失败:', error);
                // 尝试解析响应文本以获取详细错误信息
                try {
                    var response = JSON.parse(xhr.responseText);
                    if (!handleBtApiError(response, '获取PHP版本列表失败')) {
                        if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                            layer.msg('获取PHP版本列表失败: ' + (response.msg || error), {icon: 2});
                        } else {
                            alert('获取PHP版本列表失败: ' + (response.msg || error));
                        }
                    }
                } catch (e) {
                    if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                        layer.msg('获取PHP版本列表失败', {icon: 2});
                    } else {
                        alert('获取PHP版本列表失败');
                    }
                }
            }
        });
    },
    error: function (xhr, status, error) {
        console.log('获取当前PHP版本失败:', error);
        // 尝试解析响应文本以获取详细错误信息
        try {
            var response = JSON.parse(xhr.responseText);
            if (!handleBtApiError(response, '获取当前PHP版本失败')) {
                if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                    layer.msg('获取当前PHP版本失败: ' + (response.msg || error), {icon: 2});
                } else {
                    alert('获取当前PHP版本失败: ' + (response.msg || error));
                }
            }
        } catch (e) {
            if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                layer.msg('获取当前PHP版本失败', {icon: 2});
            } else {
                alert('获取当前PHP版本失败');
            }
        }
    }
});
   
   //主机负载图表
   if (document.getElementById('myChart')) {
       // 检查Chart.js是否已正确加载
       if (!checkChartJS()) {
           console.error('Chart.js未正确加载，无法初始化主机负载图表');
           if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
               layer.alert('图表库加载失败，请刷新页面重试', {title: '错误', icon: 2});
           } else {
               alert('图表库加载失败，请刷新页面重试');
           }
           return;
       }
       
       var ctx = document.getElementById('myChart'); 
       var chartData = {  
           labels: [], 
           datasets: [{  
               label: "主机负载状况(%)", 
               backgroundColor: 'rgba(255, 99, 132, 0.2)',  
               borderColor: 'rgb(255, 99, 132)',  
               borderWidth: 2,
               data: [],  
               fill: true,  // 改为面积图
               tension: 0.1
           }]  
       };   
       
       var chart = new Chart(ctx, {  
           type: 'line',  // 保持line类型，但通过fill:true实现面积图效果
           data: chartData,  
           options: { 
               responsive: true,
               maintainAspectRatio: false,
               scales: {  
                   //设置y坐标
                   y: {  
                       beginAtZero: true,  
                       max: 100,  
                       min: 0,  
                       ticks: {
                           stepSize: 10,
                           callback: function(value, index, values) {  
                               return value + "%";  
                           }  
                       }
                   },
                   x: {
                       ticks: {
                           maxTicksLimit: 10
                       }
                   }
               },
               animation: {
                   duration: 500  // 保持动画时间，使更新更流畅
               },
               elements: {
                   point: {
                       radius: 3
                   }
               }
               // 移除 transitions 配置，使用默认的动画效果
           }  
       });

       var continueRequest = true;

       function updateChart() {
           // 检查是否应该继续请求
           if (!continueRequest) {
               console.log('主机负载监控已停止');
               return;
           }
           
           $.ajax({
               url: "/main/GetNetWork",
               type: "POST",
               timeout: 10000, // 10秒超时
               success: function (response) {
                   // 重置错误计数
                   loadErrorCount = 0;
                   
                   //console.log('负载数据:', response);
                   
                   // 检查是否有错误信息
                   if (response.error) {
                       console.warn('API返回错误信息:', response.error);
                   }
                   
                   // 检查响应是否包含所需字段
                   // 修改这里以正确访问cpu_times字段
                   var cpuTimes = response.cpu_times || {};
                   if (typeof response !== 'object' || response === null || 
                       (typeof cpuTimes.user === 'undefined' && 
                        typeof cpuTimes.system === 'undefined' && 
                        typeof cpuTimes.iowait === 'undefined' && 
                        typeof cpuTimes.softirq === 'undefined' && 
                        typeof cpuTimes.idle === 'undefined')) {
                       // 如果响应不包含所需字段，尝试提取msg字段
                       var errorMsg = '服务器返回数据格式不正确';
                       if (response && typeof response.msg !== 'undefined') {
                           errorMsg = response.msg;
                       } else if (response && typeof response.message !== 'undefined') {
                           errorMsg = response.message;
                       } else {
                           errorMsg = JSON.stringify(response, null, 2);
                       }
                       
                       console.warn('服务器返回数据格式不正确，停止请求:', response);
                       continueRequest = false;
                       
                       // 显示错误信息
                       if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
                           layer.alert('获取负载数据失败:<br>' + errorMsg, {
                               title: '错误',
                               icon: 2
                           });
                       } else {
                           alert('获取负载数据失败:\n' + errorMsg);
                       }
                       
                       // 清理定时器
                       clearInterval(chartInterval);
                       console.log('已停止主机负载监控');
                       return;
                   }
                   
                   // 改进的负载计算公式
                   // 修改这里以正确访问cpu_times字段
                   var totalTime = (cpuTimes.user || 0) + (cpuTimes.system || 0) + (cpuTimes.iowait || 0) + (cpuTimes.softirq || 0) + (cpuTimes.idle || 0);
                   var usedTime = (cpuTimes.user || 0) + (cpuTimes.system || 0) + (cpuTimes.iowait || 0) + (cpuTimes.softirq || 0);
                   
                   // 只有在totalTime大于0时才计算负载，避免除以0的情况
                   var dataValues = 0;
                   if (totalTime > 0) {
                       dataValues = (usedTime / totalTime * 100);
                   } else {
                       // 如果totalTime为0，使用上一个数据点的值（如果存在）
                       var lastDataPoint = chartData.datasets[0].data.length > 0 ? 
                                          parseFloat(chartData.datasets[0].data[chartData.datasets[0].data.length - 1]) : 0;
                       dataValues = lastDataPoint;
                   }
                   
                   //console.log('计算负载值:', dataValues.toFixed(2) + '%');

                   // 检查数据是否合理
                   if (isNaN(dataValues) || dataValues < 0) {
                       console.error('负载数据异常(NaN或负数):', dataValues);
                       // 如果数据异常，使用上一个数据点的值（如果存在）
                       var lastDataPoint = chartData.datasets[0].data.length > 0 ? 
                                          parseFloat(chartData.datasets[0].data[chartData.datasets[0].data.length - 1]) : 0;
                       dataValues = lastDataPoint;
                   }
                   
                   // 限制数据范围在0-100之间
                   dataValues = Math.max(0, Math.min(100, dataValues));

                   // 添加新数据点
                   chartData.datasets[0].data.push(dataValues.toFixed(2)); 
                   
                   //获取当前时间更新labels
                   var date = new Date();
                   chartData.labels.push(date.toLocaleTimeString());
                   
                   // 保持最多10个数据点
                   if (chartData.labels.length > 10) {
                       chartData.labels.shift();
                       chartData.datasets[0].data.shift();
                   }
                   
                   // 更新图表
                   chart.update(); // 恢复默认的动画效果
               },
               error: function (xhr, status, error) {
                   console.error('获取负载数据失败:', {
                       status: xhr.status,
                       statusText: xhr.statusText,
                       error: error
                   });
                   
                   // 增加错误计数
                   loadErrorCount++;
                   console.log('负载数据获取失败次数:', loadErrorCount);
                   
                   // 只有在错误次数超过最大允许次数时才停止请求
                   if (loadErrorCount >= maxLoadErrors) {
                       // 停止继续请求
                       continueRequest = false;
                       
                       // 尝试解析响应文本以获取详细错误信息
                       try {
                           var response = JSON.parse(xhr.responseText);
                           if (!handleBtApiError(response, '获取负载数据失败')) {
                               // 显示错误信息弹窗
                               if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
                                   layer.alert('获取负载数据失败: ' + (response.msg || error), {
                                       title: '错误',
                                       icon: 2
                                   });
                               } else {
                                   alert('获取负载数据失败: ' + (response.msg || error));
                               }
                           }
                       } catch (e) {
                           // 显示错误信息弹窗
                           if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
                               layer.alert('获取负载数据失败: ' + error, {
                                   title: '错误',
                                   icon: 2
                               });
                           } else {
                               alert('获取负载数据失败: ' + error);
                           }
                       }
                       
                       // 清理定时器
                       clearInterval(chartInterval);
                       console.log('已停止主机负载监控');
                   } else {
                       console.log('负载数据获取失败，但未达到最大错误次数，继续监控...');
                       
                       // 即使获取数据失败，也添加一个占位数据点以保持图表的连续性
                       var lastDataPoint = chartData.datasets[0].data.length > 0 ? 
                                          parseFloat(chartData.datasets[0].data[chartData.datasets[0].data.length - 1]) : 0;
                       chartData.datasets[0].data.push(lastDataPoint.toFixed(2));
                       
                       //获取当前时间更新labels
                       var date = new Date();
                       chartData.labels.push(date.toLocaleTimeString());
                       
                       // 保持最多10个数据点
                       if (chartData.labels.length > 10) {
                           chartData.labels.shift();
                           chartData.datasets[0].data.shift();
                       }
                       
                       // 更新图表
                       chart.update(); // 恢复默认的动画效果
                   }
               }
           });  
       }

       // 启动定时更新
       console.log('启动主机负载监控...');
       updateChart(); // 立即执行一次
       var chartInterval = setInterval(updateChart, 5000); // 将更新频率从3秒调整为5秒，使变化更平滑
       
       // 在页面卸载时清理定时器
       window.addEventListener('beforeunload', function() {
           clearInterval(chartInterval);
           console.log('停止主机负载监控');
       });
   } else {
       console.log('未找到myChart元素，跳过负载图表初始化');
   }
});

// 在文档就绪函数外部添加错误计数变量
var loadErrorCount = 0;  // 添加这一行
var maxLoadErrors = 5;   // 添加这一行

$(document).ready(function () {
   // 获取myChart元素
   var ctx = document.getElementById('myChart');
   if (ctx) {
       // 检查Chart.js是否已正确加载
       if (!checkChartJS()) {
           console.error('Chart.js未正确加载，无法初始化主机负载图表');
           if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
               layer.alert('图表库加载失败，请刷新页面重试', {title: '错误', icon: 2});
           } else {
               alert('图表库加载失败，请刷新页面重试');
           }
           return;
       }
       
       var ctx = document.getElementById('myChart'); 
       var chartData = {  
           labels: [], 
           datasets: [{  
               label: "主机负载状况(%)", 
               backgroundColor: 'rgba(255, 99, 132, 0.2)',  
               borderColor: 'rgb(255, 99, 132)',  
               borderWidth: 2,
               data: [],  
               fill: false,
               tension: 0.1
           }]  
       };   
       
       var chart = new Chart(ctx, {  
           type: 'line',  
           data: chartData,  
           options: { 
               responsive: true,
               maintainAspectRatio: false,
               scales: {  
                   //设置y坐标
                   y: {  
                       beginAtZero: true,  
                       max: 100,  
                       min: 0,  
                       ticks: {
                           stepSize: 10,
                           callback: function(value, index, values) {  
                               return value + "%";  
                           }  
                       }
                   },
                   x: {
                       ticks: {
                           maxTicksLimit: 10
                       }
                   }
               },
               animation: {
                   duration: 1000
               },
               elements: {
                   point: {
                       radius: 3
                   }
               }
           }  
       });

       var continueRequest = true;

       function updateChart() {
           // 检查是否应该继续请求
           if (!continueRequest) {
               console.log('主机负载监控已停止');
               return;
           }
           
           $.ajax({
               url: "/main/GetNetWork",
               type: "POST",
               timeout: 10000, // 10秒超时
               success: function (response) {
                   // 重置错误计数
                   loadErrorCount = 0;
                   
                   //console.log('负载数据:', response);
                   
                   // 检查是否有错误信息
                   if (response.error) {
                       console.warn('API返回错误信息:', response.error);
                   }
                   
                   // 检查响应是否包含所需字段
                   // 修改这里以正确访问cpu_times字段
                   var cpuTimes = response.cpu_times || {};
                   if (typeof response !== 'object' || response === null || 
                       (typeof cpuTimes.user === 'undefined' && 
                        typeof cpuTimes.system === 'undefined' && 
                        typeof cpuTimes.iowait === 'undefined' && 
                        typeof cpuTimes.softirq === 'undefined' && 
                        typeof cpuTimes.idle === 'undefined')) {
                       // 如果响应不包含所需字段，尝试提取msg字段
                       var errorMsg = '服务器返回数据格式不正确';
                       if (response && typeof response.msg !== 'undefined') {
                           errorMsg = response.msg;
                       } else if (response && typeof response.message !== 'undefined') {
                           errorMsg = response.message;
                       } else {
                           errorMsg = JSON.stringify(response, null, 2);
                       }
                       
                       console.warn('服务器返回数据格式不正确，停止请求:', response);
                       continueRequest = false;
                       
                       // 显示错误信息
                       if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
                           layer.alert('获取负载数据失败:<br>' + errorMsg, {
                               title: '错误',
                               icon: 2
                           });
                       } else {
                           alert('获取负载数据失败:\n' + errorMsg);
                       }
                       
                       // 清理定时器
                       clearInterval(chartInterval);
                       console.log('已停止主机负载监控');
                       return;
                   }
                   
                   // 改进的负载计算公式
                   // 修改这里以正确访问cpu_times字段
                   var totalTime = (cpuTimes.user || 0) + (cpuTimes.system || 0) + (cpuTimes.iowait || 0) + (cpuTimes.softirq || 0) + (cpuTimes.idle || 0);
                   var usedTime = (cpuTimes.user || 0) + (cpuTimes.system || 0) + (cpuTimes.iowait || 0) + (cpuTimes.softirq || 0);
                   var dataValues = totalTime > 0 ? (usedTime / totalTime * 100) : 0;
                   
                   //console.log('计算负载值:', dataValues.toFixed(2) + '%');

                   // 检查数据是否合理
                   if (isNaN(dataValues) || dataValues < 0) {
                       console.error('负载数据异常(NaN或负数):', dataValues);
                       dataValues = 0; // 设置默认值
                   }
                   
                   // 限制数据范围在0-100之间
                   dataValues = Math.max(0, Math.min(100, dataValues));

                   // 添加新数据点
                   chartData.datasets[0].data.push(dataValues.toFixed(2)); 
                   
                   //获取当前时间更新labels
                   var date = new Date();
                   chartData.labels.push(date.toLocaleTimeString());
                   
                   // 保持最多10个数据点
                   if (chartData.labels.length > 10) {
                       chartData.labels.shift();
                       chartData.datasets[0].data.shift();
                   }
                   
                   // 更新图表
                   chart.update();
               },
               error: function (xhr, status, error) {
                   console.error('获取负载数据失败:', {
                       status: xhr.status,
                       statusText: xhr.statusText,
                       error: error
                   });
                   
                   // 增加错误计数
                   loadErrorCount++;
                   console.log('负载数据获取失败次数:', loadErrorCount);
                   
                   // 只有在错误次数超过最大允许次数时才停止请求
                   if (loadErrorCount >= maxLoadErrors) {
                       // 停止继续请求
                       continueRequest = false;
                       
                       // 尝试解析响应文本以获取详细错误信息
                       try {
                           var response = JSON.parse(xhr.responseText);
                           if (!handleBtApiError(response, '获取负载数据失败')) {
                               // 显示错误信息弹窗
                               if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
                                   layer.alert('获取负载数据失败: ' + (response.msg || error), {
                                       title: '错误',
                                       icon: 2
                                   });
                               } else {
                                   alert('获取负载数据失败: ' + (response.msg || error));
                               }
                           }
                       } catch (e) {
                           // 显示错误信息弹窗
                           if (typeof layer !== 'undefined' && typeof layer.alert !== 'undefined') {
                               layer.alert('获取负载数据失败: ' + error, {
                                   title: '错误',
                                   icon: 2
                               });
                           } else {
                               alert('获取负载数据失败: ' + error);
                           }
                       }
                       
                       // 清理定时器
                       clearInterval(chartInterval);
                       console.log('已停止主机负载监控');
                   } else {
                       console.log('负载数据获取失败，但未达到最大错误次数，继续监控...');
                   }
               }
           });  
       }

       // 启动定时更新
       console.log('启动主机负载监控...');
       updateChart(); // 立即执行一次
       var chartInterval = setInterval(updateChart, 3000);
       
       // 在页面卸载时清理定时器
       window.addEventListener('beforeunload', function() {
           clearInterval(chartInterval);
           console.log('停止主机负载监控');
       });
   } else {
       console.log('未找到myChart元素，跳过负载图表初始化');
   }
});

// 切换php版本
function SetPHPVersion() {
    // 检查元素是否存在
    if (document.getElementById("php")) {
        var selectElement = document.getElementById("php");
        var selectedValue = selectElement.options[selectElement.selectedIndex].value;
        var selectedversion = selectElement.options[selectElement.selectedIndex].innerHTML;
     
        console.log(selectedversion)

        $.ajax({
            url: "/main/SetPHPVersion",
            type: "POST",
            data: {
                'phpversion': selectedValue,
            },
            success: function (response) {
                
                // 检查layer是否可用
                if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                    // 确保弹窗有正确的样式
                   
                    layer.msg(response.msg, {icon: 1, time: 2000});
                } else {
                    // 如果layer不可用，使用alert作为备选方案
                    alert(response.msg || '切换失败');
                }
            },
            error: function (xhr, status, error) {
                console.log(error);
                // 尝试解析响应文本以获取详细错误信息
                try {
                    var response = JSON.parse(xhr.responseText);
                    if (!handleBtApiError(response, '切换PHP版本失败')) {
                        // 错误处理
                        if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                            layer.msg('切换失败: ' + (response.msg || error), {icon: 2, time: 2000});
                        } else {
                            alert('切换失败: ' + (response.msg || error));
                        }
                    }
                } catch (e) {
                    if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                        layer.msg('切换失败', {icon: 2, time: 2000});
                    } else {
                        alert('切换失败');
                    }
                }
            }
        });
    }
}

function showPassword() {
    // 检查元素是否存在
    if (document.getElementById("sqlpwd") && document.getElementById("text")) {
        var element = document.getElementById("sqlpwd").innerHTML;
        console.log(element)
        var text = document.getElementById("text");
        if (text.innerHTML === '数据库密码: ******* <button style=" border: 1px solid transparent; background-color: transparent;" onclick="showPassword()"><span class="mdi mdi-eye-refresh-outline"></span></button>') {
            text.innerHTML = '数据库密码: '+element+' <button style=" border: 1px solid transparent; background-color: transparent;" onclick="showPassword()"><span class="mdi mdi-eye-refresh-outline"></span></button>';
        } else {
            text.innerHTML = '数据库密码: ******* <button style=" border: 1px solid transparent; background-color: transparent;" onclick="showPassword()"><span class="mdi mdi-eye-refresh-outline"></span></button>';
        }
    }
}


$(document).ready(function() {  
    
    
    // 获取系统信息
    $.ajax({
        url: "/main/system_info",
        type: "POST",
        success: function (response) {
            console.log('系统信息响应:', response);
            
            // 提取系统信息
            var systemType = 'Unknown';
            var version = 'Unknown';
            var uptimeInfo = '';
            
            if (typeof response === 'object' && response !== null) {
                // 从响应中提取信息
                systemType = response.system || 'Unknown';
                version = response.version || 'Unknown';
                uptimeInfo = response.time || '';
            } else if (typeof response === 'string') {
                // 如果是字符串，尝试解析JSON
                try {
                    var parsedResponse = JSON.parse(response);
                    if (typeof parsedResponse === 'object' && parsedResponse !== null) {
                        systemType = parsedResponse.system || 'Unknown';
                        version = parsedResponse.version || 'Unknown';
                        uptimeInfo = parsedResponse.time || '';
                    } else {
                        systemType = parsedResponse;
                    }
                } catch (e) {
                    systemType = response;
                }
            }
            
            console.log('系统类型:', systemType, '版本:', version, '运行时间:', uptimeInfo);
            
            // 构建显示内容
            var systemInfoHTML = '';
            
            // 显示系统类型 - 简化显示
            if (systemType.includes('Ubuntu')) {
                systemInfoHTML += '<svg class="icon" style="font-size: 20px;" aria-hidden="true"><use xlink:href="#icon-Ubuntu"></use></svg>&nbsp;<span style="color: #CC6600;">Ubuntu</span>';
            } else if (systemType.includes('CentOS')) {
                systemInfoHTML += '<svg class="icon" style="font-size: 20px;" aria-hidden="true"><use xlink:href="#icon-centos"></use></svg>&nbsp;CentOS';
            } else if (systemType.includes('Debian')) {
                systemInfoHTML += '<svg class="icon" style="font-size: 20px;" aria-hidden="true"><use xlink:href="#icon-deepin"></use></svg>&nbsp;<span style="color: #00BBFF;">Debian</span>';
            } else {
                // 如果不是预定义的系统类型，显示简化的系统信息
                // 只显示系统名称部分，去掉版本和架构信息
                var simpleSystem = systemType.split(' ')[0];
                systemInfoHTML += simpleSystem;
            }
            
            // 添加版本信息
            if (version && version !== 'Unknown') {
                systemInfoHTML += '<br>宝塔版本: ' + version;
            }
            
            // 添加运行时间信息
            if (uptimeInfo && uptimeInfo !== '') {
                systemInfoHTML += '<br>运行时间: ' + uptimeInfo;
            }
            
            // 更新页面内容
            document.getElementById("linux").innerHTML = systemInfoHTML;
        },
        error: function (xhr, status, error) {
            console.log('获取系统信息失败:', error);
            console.log('响应内容:', xhr.responseText);
            // 尝试解析响应文本以获取详细错误信息
            try {
                var response = JSON.parse(xhr.responseText);
                if (!handleBtApiError(response, '获取系统信息失败')) {
                    if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                        layer.msg('获取系统信息失败: ' + (response.msg || error), {icon: 2});
                    } else {
                        alert('获取系统信息失败: ' + (response.msg || error));
                    }
                }
            } catch (e) {
                if (typeof layer !== 'undefined' && typeof layer.msg !== 'undefined') {
                    layer.msg('获取系统信息失败', {icon: 2});
                } else {
                    alert('获取系统信息失败');
                }
            }
        }
    });
    
    
});